#include "../include/node_manager.h"
#include "logger.h"
#include <sstream>
#include <iostream>
#include <chrono>
#include <thread>
#include <functional>
#include <json/json.h>
#include <random>

// 常量定义
const std::string NODE_PREFIX = "/nodes/";
const std::string LEADER_KEY = "/leader";
const std::string PERSISTENT_NODE_PREFIX = "/persistent_nodes/";

// 构造函数
NodeManager::NodeManager(const std::string& etcdUrl, const std::string& nodeId, const std::string& endpoint)
    : m_etcdUrl(etcdUrl),
      m_nodeId(nodeId),
      m_endpoint(endpoint),
      m_status(NodeStatus::UNKNOWN),
      m_running(false),
      m_etcdClient(nullptr),
      m_leaseId(0) {
    LOG_DEBUG("NodeManager构造: nodeId=" + nodeId + ", endpoint=" + endpoint);
}

// 析构函数
NodeManager::~NodeManager() {
    LOG_DEBUG("NodeManager析构: nodeId=" + m_nodeId);
    stop();
    if (m_etcdClient) {
        delete m_etcdClient;
        m_etcdClient = nullptr;
    }
}

// 初始化
bool NodeManager::init() {
    LOG_INFO("初始化节点管理器: nodeId=" + m_nodeId);
    
    try {
        m_etcdClient = new EtcdClient(m_etcdUrl);
        return m_etcdClient->init();
    } catch (const std::exception& e) {
        LOG_ERROR("初始化节点管理器失败: " + std::string(e.what()));
        return false;
    }
}

// 启动节点
bool NodeManager::start() {
    // 如果已经在运行，直接返回
    if (m_running) {
        LOG_WARNING("节点已经在运行中: nodeId=" + m_nodeId);
        return true;
    }

    LOG_INFO("启动节点: nodeId=" + m_nodeId);
    
    try {
        // 获取租约
        if (!createLease()) {
            LOG_ERROR("创建租约失败: nodeId=" + m_nodeId);
            return false;
        }

        // 加载持久化节点信息
        loadPersistentNodeInfo();

        // 注册节点
        if (!registerNode()) {
            LOG_ERROR("注册节点失败: nodeId=" + m_nodeId);
            return false;
        }

        // 标记为运行中
        m_running = true;

        // 启动心跳线程
        m_heartbeatThread = std::thread(&NodeManager::heartbeatLoop, this);
        
        // 启动选举线程
        m_electionThread = std::thread(&NodeManager::electionLoop, this);

        LOG_INFO("节点成功启动: nodeId=" + m_nodeId);
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("启动节点失败: " + std::string(e.what()));
        return false;
    }
}

// 停止节点
void NodeManager::stop() {
    if (!m_running) {
        LOG_DEBUG("节点未运行，无需停止: nodeId=" + m_nodeId);
        return;
    }

    LOG_INFO("停止节点: nodeId=" + m_nodeId);
    
    // 标记为不再运行
    m_running = false;

    // 等待线程结束
    if (m_heartbeatThread.joinable()) {
        m_heartbeatThread.join();
    }
    
    if (m_electionThread.joinable()) {
        m_electionThread.join();
    }

    // 注销节点
    unregisterNode();
    
    // 释放租约
    revokeLease();
    
    LOG_INFO("节点成功停止: nodeId=" + m_nodeId);
}

// 获取所有节点
std::vector<NodeInfo> NodeManager::getAllNodes() const {
    LOG_DEBUG("获取所有节点");
    
    // 首先获取所有持久化节点
    std::vector<NodeInfo> persistentNodes = getAllPersistentNodes();
    
    // 然后获取活动节点信息
    try {
        EtcdResult result = m_etcdClient->getPrefix(NODE_PREFIX);
        if (!result.success) {
            LOG_ERROR("获取活动节点列表失败: " + result.errorMessage);
            return persistentNodes;  // 如果获取活动节点失败，至少返回持久化节点
        }

        std::map<std::string, NodeInfo> nodeMap;
        // 先将持久化节点放入映射
        for (const auto& node : persistentNodes) {
            nodeMap[node.id] = node;
        }
        
        // 合并活动节点信息
        for (const auto& kv : result.kvs) {
            NodeInfo nodeInfo;
            if (deserializeNodeInfo(kv.second, nodeInfo)) {
                // 如果节点已存在于映射中，更新其状态和时间信息
                if (nodeMap.find(nodeInfo.id) != nodeMap.end()) {
                    nodeMap[nodeInfo.id].status = nodeInfo.status;
                    nodeMap[nodeInfo.id].lastHeartbeat = nodeInfo.lastHeartbeat;
                } else {
                    // 否则添加新节点
                    nodeMap[nodeInfo.id] = nodeInfo;
                }
            } else {
                LOG_WARNING("无法解析节点信息: " + kv.first);
            }
        }
        
        // 将映射转换回向量
        std::vector<NodeInfo> mergedNodes;
        for (const auto& pair : nodeMap) {
            mergedNodes.push_back(pair.second);
        }
        
        LOG_DEBUG("找到节点总数量: " + std::to_string(mergedNodes.size()));
        return mergedNodes;
    } catch (const std::exception& e) {
        LOG_ERROR("获取节点列表异常: " + std::string(e.what()));
    }
    
    return persistentNodes;  // 出错时返回持久化节点
}

// 获取当前节点ID
std::string NodeManager::getCurrentNodeId() const {
    return m_nodeId;
}

// 获取当前节点信息
NodeInfo NodeManager::getCurrentNodeInfo() const {
    NodeInfo info;
    info.id = m_nodeId;
    info.endpoint = m_endpoint;
    info.status = m_status;
    info.joinTime = m_joinTime;
    info.lastHeartbeat = m_lastHeartbeat;
    return info;
}

// 获取主节点
bool NodeManager::getLeaderNode(std::string& leaderId, NodeInfo& leaderInfo) {
    LOG_DEBUG("获取主节点信息");
    
    try {
        // 从ETCD获取主节点ID
        EtcdResult result = m_etcdClient->get(LEADER_KEY);
        if (!result.success) {
            LOG_WARNING("获取主节点ID失败: " + result.errorMessage);
            return false;
        }
        
        if (result.value.empty()) {
            LOG_DEBUG("无主节点");
            return false;
        }
        
        leaderId = result.value;
        LOG_DEBUG("获取到主节点ID: " + leaderId);
        
        // 获取主节点详细信息
        EtcdResult nodeResult = m_etcdClient->get(NODE_PREFIX + leaderId);
        if (!nodeResult.success) {
            LOG_WARNING("获取主节点详细信息失败: " + nodeResult.errorMessage);
            return false;
        }
        
        if (nodeResult.value.empty()) {
            LOG_WARNING("主节点详细信息为空");
            
            // 如果当前节点是从节点，可能需要清理主节点记录
            if (m_status == NodeStatus::FOLLOWER) {
                LOG_INFO("主节点信息为空但LEADER_KEY存在，清理主节点记录");
                m_etcdClient->del(LEADER_KEY);
            }
            
            return false;
        }
        
        // 解析主节点信息
        if (!deserializeNodeInfo(nodeResult.value, leaderInfo)) {
            LOG_WARNING("解析主节点信息失败");
            return false;
        }
        
        // 检查主节点状态
        if (leaderInfo.status != NodeStatus::LEADER) {
            LOG_WARNING("主节点状态不正确: " + nodeStatusToString(leaderInfo.status));
            return false;
        }
        
        LOG_DEBUG("成功获取主节点信息: id=" + leaderInfo.id);
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("获取主节点异常: " + std::string(e.what()));
        return false;
    }
}

// 获取当前节点状态
NodeStatus NodeManager::getStatus() const {
    std::lock_guard<std::mutex> lock(m_mutex);
    return m_status;
}

// 注册状态变更回调
void NodeManager::registerStatusCallback(std::function<void(NodeStatus, NodeStatus)> callback) {
    m_statusCallback = callback;
}

// 注册节点加入回调
void NodeManager::registerNodeJoinCallback(std::function<void(const NodeInfo&)> callback) {
    m_nodeJoinCallback = callback;
}

// 注册节点离开回调
void NodeManager::registerNodeLeaveCallback(std::function<void(const NodeInfo&)> callback) {
    m_nodeLeaveCallback = callback;
}

// 模拟故障
bool NodeManager::simulateFault() {
    if (!m_running) {
        LOG_WARNING("节点未运行，无法模拟故障: nodeId=" + m_nodeId);
        return false;
    }

    LOG_INFO("模拟节点故障: nodeId=" + m_nodeId);
    
    try {
        // 更新状态为故障
        updateStatus(NodeStatus::FAULT);
        
        // 更新节点信息
        bool result = updateNodeInfo();
        
        // 更新持久化节点信息，标记故障状态（不删除）
        // 序列化节点基本信息（包含故障状态）
        Json::Value root;
        root["id"] = m_nodeId;
        root["endpoint"] = m_endpoint;
        root["status"] = static_cast<int>(NodeStatus::FAULT); // 明确标记为故障状态
        root["createdAt"] = Json::Value::Int64(std::chrono::duration_cast<std::chrono::milliseconds>(
            m_joinTime.time_since_epoch()).count());
        root["faultTime"] = Json::Value::Int64(std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::system_clock::now().time_since_epoch()).count());
        
        Json::FastWriter writer;
        std::string basicInfoJson = writer.write(root);
        
        // 将更新后的信息写入持久化存储
        std::string persistentKey = PERSISTENT_NODE_PREFIX + m_nodeId;
        EtcdResult putResult = m_etcdClient->put(persistentKey, basicInfoJson);
        if (!putResult.success) {
            LOG_WARNING("更新持久化节点故障状态失败: " + putResult.errorMessage);
        } else {
            LOG_INFO("已在持久化存储中更新节点故障状态: " + m_nodeId);
        }
        
        return result;
    } catch (const std::exception& e) {
        LOG_ERROR("模拟节点故障失败: " + std::string(e.what()));
        return false;
    }
}

// 模拟恢复
bool NodeManager::simulateRecover() {
    if (!m_running) {
        LOG_WARNING("节点未运行，无法模拟恢复: nodeId=" + m_nodeId);
        return false;
    }

    LOG_INFO("模拟节点恢复: nodeId=" + m_nodeId);
    
    try {
        // 更新状态为从节点
        updateStatus(NodeStatus::FOLLOWER);
        
        // 更新节点信息
        return updateNodeInfo();
    } catch (const std::exception& e) {
        LOG_ERROR("模拟节点恢复失败: " + std::string(e.what()));
        return false;
    }
}

// 创建租约
bool NodeManager::createLease() {
    LOG_DEBUG("创建租约: nodeId=" + m_nodeId);
    
    try {
        EtcdResult result = m_etcdClient->grantLease(LEASE_TTL);
        if (!result.success) {
            LOG_ERROR("创建租约失败: " + result.errorMessage);
            return false;
        }

        // 尝试安全地转换字符串为整数
        try {
            std::string leaseStr = result.value;
            LOG_DEBUG("租约ID字符串值: '" + leaseStr + "'");
            
            // 去除字符串前后可能的空白字符
            leaseStr.erase(0, leaseStr.find_first_not_of(" \n\r\t"));
            leaseStr.erase(leaseStr.find_last_not_of(" \n\r\t") + 1);
            
            if (leaseStr.empty()) {
                LOG_ERROR("租约ID为空");
                return false;
            }
            
            // 检查字符串是否只包含数字
            if (leaseStr.find_first_not_of("0123456789") != std::string::npos) {
                LOG_ERROR("租约ID包含非数字字符: '" + leaseStr + "'");
                return false;
            }
            
            m_leaseId = std::stoll(leaseStr);
            LOG_INFO("成功创建租约ID: " + std::to_string(m_leaseId));
            return true;
        } catch (const std::exception& e) {
            LOG_ERROR("解析租约ID异常: " + std::string(e.what()) + ", 原始值: '" + result.value + "'");
            return false;
        }
    } catch (const std::exception& e) {
        LOG_ERROR("创建租约异常: " + std::string(e.what()));
        return false;
    }
}

// 续约
bool NodeManager::renewLease() {
    if (m_leaseId == 0) {
        LOG_WARNING("租约ID无效，无法续约");
        return false;
    }
    
    LOG_DEBUG("续约: leaseId=" + std::to_string(m_leaseId));
    
    try {
        EtcdResult result = m_etcdClient->keepAliveLease(m_leaseId);
        if (!result.success) {
            LOG_WARNING("续约失败: " + result.errorMessage);
            return false;
        }
        
        LOG_DEBUG("续约成功: leaseId=" + std::to_string(m_leaseId));
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("续约异常: " + std::string(e.what()));
        return false;
    }
}

// 撤销租约
void NodeManager::revokeLease() {
    if (m_leaseId == 0) {
        return;
    }
    
    LOG_DEBUG("撤销租约: leaseId=" + std::to_string(m_leaseId));
    
    try {
        m_etcdClient->revokeLease(m_leaseId);
        m_leaseId = 0;
    } catch (const std::exception& e) {
        LOG_ERROR("撤销租约异常: " + std::string(e.what()));
    }
}

// 注册节点
bool NodeManager::registerNode() {
    LOG_INFO("注册节点: nodeId=" + m_nodeId);
    
    try {
        // 设置初始状态为从节点
        m_status = NodeStatus::FOLLOWER;
        
        // 设置加入时间
        m_joinTime = std::chrono::system_clock::now();
        
        // 更新心跳时间
        m_lastHeartbeat = m_joinTime;
        
        // 先保存持久化节点信息（不带租约，永久保存）
        if (!savePersistentNodeInfo()) {
            LOG_ERROR("保存持久化节点信息失败: nodeId=" + m_nodeId);
            // 持久化失败不阻止注册，继续执行
        }
        
        // 序列化节点信息
        std::string nodeInfoJson = serializeNodeInfo();
        
        // 将节点信息写入ETCD（带租约，临时存储）
        EtcdResult result = m_etcdClient->put(NODE_PREFIX + m_nodeId, nodeInfoJson, m_leaseId);
        if (!result.success) {
            LOG_ERROR("写入节点信息失败: " + result.errorMessage);
            return false;
        }
        
        LOG_INFO("节点注册成功: nodeId=" + m_nodeId);
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("注册节点异常: " + std::string(e.what()));
        return false;
    }
}

// 注销节点
void NodeManager::unregisterNode() {
    LOG_INFO("注销节点: " + m_nodeId);
    
    try {
        // 如果是主节点，删除主节点键
        if (m_status == NodeStatus::LEADER) {
            LOG_INFO("当前是主节点，删除主节点键");
            m_etcdClient->del(LEADER_KEY);
        }
        
        // 删除节点临时信息键（带租约的）
        m_etcdClient->del(NODE_PREFIX + m_nodeId);
        
        // 持久化信息不删除，保持在ETCD中
        LOG_INFO("节点临时信息已删除，持久化信息保留: nodeId=" + m_nodeId);
    } catch (const std::exception& e) {
        LOG_ERROR("注销节点异常: " + std::string(e.what()));
    }
}

// 更新节点信息
bool NodeManager::updateNodeInfo() {
    LOG_DEBUG("更新节点信息: nodeId=" + m_nodeId);
    
    try {
        // 更新心跳时间
        m_lastHeartbeat = std::chrono::system_clock::now();
        
        // 序列化节点信息
        std::string nodeInfoJson = serializeNodeInfo();
        
        // 将节点信息写入ETCD
        EtcdResult result = m_etcdClient->put(NODE_PREFIX + m_nodeId, nodeInfoJson, m_leaseId);
        if (!result.success) {
            LOG_ERROR("更新节点信息失败: " + result.errorMessage);
            return false;
        }
        
        LOG_DEBUG("节点信息更新成功: nodeId=" + m_nodeId);
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("更新节点信息异常: " + std::string(e.what()));
        return false;
    }
}

// 更新状态
void NodeManager::updateStatus(NodeStatus newStatus) {
    if (m_status == newStatus) {
        return;
    }
    
    LOG_INFO("节点状态变更: nodeId=" + m_nodeId + 
             ", 从 " + nodeStatusToString(m_status) + 
             " 到 " + nodeStatusToString(newStatus));
    
    NodeStatus oldStatus = m_status;
    m_status = newStatus;
    
    // 调用状态变更回调
    if (m_statusCallback) {
        m_statusCallback(oldStatus, newStatus);
    }
}

// 心跳循环
void NodeManager::heartbeatLoop() {
    LOG_INFO("心跳线程启动: nodeId=" + m_nodeId);
    
    while (m_running) {
        try {
            // 续约
            if (!renewLease()) {
                // 如果续约失败，尝试重新创建租约
                LOG_WARNING("续约失败，尝试重新创建租约: nodeId=" + m_nodeId);
                if (createLease()) {
                    // 使用新租约更新节点信息
                    registerNode();
                }
            }
            
            // 更新节点信息
            updateNodeInfo();
            
            // 休眠
            std::this_thread::sleep_for(std::chrono::seconds(HEARTBEAT_INTERVAL));
        } catch (const std::exception& e) {
            LOG_ERROR("心跳循环异常: " + std::string(e.what()));
            // 短暂休眠后继续
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
    }
    
    LOG_INFO("心跳线程停止: nodeId=" + m_nodeId);
}

// 选举循环
void NodeManager::electionLoop() {
    LOG_INFO("启动选举线程: nodeId=" + m_nodeId);
    
    // 先等待1秒钟，让系统稳定
    std::this_thread::sleep_for(std::chrono::seconds(1));
    
    // 直接尝试成为Leader（初始选举）
    bool initialElection = tryBecomeLeader();
    LOG_INFO("初始选举结果: " + std::string(initialElection ? "成功" : "失败"));
    
    // 随机数生成器
    std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_int_distribution<> delayDist(300, 1000); // 0.3-1秒的随机延迟，更快地响应
    
    // 连续失败计数
    int consecutiveFailures = 0;
    
    // 记录上次选举尝试时间
    auto lastElectionAttempt = std::chrono::system_clock::now();
    
    while (m_running) {
        try {
            // 如果节点处于故障状态，暂停选举
            if (m_status == NodeStatus::FAULT) {
                LOG_DEBUG("节点处于故障状态，暂停选举");
                std::this_thread::sleep_for(std::chrono::seconds(ELECTION_INTERVAL));
                continue;
            }
            
            // 获取当前主节点
            std::string leaderId;
            NodeInfo leaderInfo;
            bool leaderExists = getLeaderNode(leaderId, leaderInfo);
            
            // 如果主节点存在且不是自己
            if (leaderExists && leaderId != m_nodeId) {
                LOG_DEBUG("主节点存在: " + leaderId);
                
                // 检查主节点健康状态
                checkLeaderHealth(leaderId);
                
                // 如果当前是主节点但存在另一个主节点（脑裂情况）
                if (m_status == NodeStatus::LEADER) {
                    LOG_WARNING("检测到脑裂情况，主节点争用: 当前节点=" + m_nodeId + ", 其他主节点=" + leaderId);
                    // 先尝试重新获取当前主节点（其他节点可能也在检查）
                    std::this_thread::sleep_for(std::chrono::milliseconds(delayDist(gen)));
                    std::string newLeaderId;
                    NodeInfo newLeaderInfo;
                    if (getLeaderNode(newLeaderId, newLeaderInfo) && newLeaderId != m_nodeId) {
                        LOG_INFO("已确认另一个主节点: " + newLeaderId + "，切换为从节点");
                        updateStatus(NodeStatus::FOLLOWER);
                        updateNodeInfo();
                    }
                } 
                // 如果当前节点不是主节点，确保状态为从节点
                else if (m_status != NodeStatus::FOLLOWER) {
                    LOG_INFO("设置为从节点: nodeId=" + m_nodeId);
                    updateStatus(NodeStatus::FOLLOWER);
                    updateNodeInfo();
                }
                
                consecutiveFailures = 0; // 重置失败计数
            }
            // 无主节点或自己是主节点
            else {
                if (leaderExists && leaderId == m_nodeId) {
                    // 自己是主节点，确保状态正确
                    if (m_status != NodeStatus::LEADER) {
                        LOG_INFO("确认为主节点: nodeId=" + m_nodeId);
                        updateStatus(NodeStatus::LEADER);
                        updateNodeInfo();
                    }
                    consecutiveFailures = 0; // 重置失败计数
                } else {
                    // 无主节点，尝试成为主节点
                    LOG_INFO("无主节点，尝试成为主节点: nodeId=" + m_nodeId);
                    
                    // 计算距离上次尝试的时间
                    auto now = std::chrono::system_clock::now();
                    auto timeSinceLastAttempt = std::chrono::duration_cast<std::chrono::milliseconds>(
                        now - lastElectionAttempt).count();
                    
                    // 只有经过了一定的时间间隔后才尝试成为主节点
                    if (timeSinceLastAttempt > 500) { // 最少等待500毫秒，避免频繁尝试
                        // 随机延迟，避免选举风暴，但延迟更短
                        int delay = delayDist(gen);
                        LOG_DEBUG("选举延迟: " + std::to_string(delay) + "毫秒");
                        std::this_thread::sleep_for(std::chrono::milliseconds(delay));
                        
                        // 记录这次尝试的时间
                        lastElectionAttempt = std::chrono::system_clock::now();
                        
                        // 尝试成为主节点
                        bool success = tryBecomeLeader();
                        
                        if (success) {
                            LOG_INFO("成功成为主节点: nodeId=" + m_nodeId);
                            consecutiveFailures = 0; // 重置失败计数
                        } else {
                            consecutiveFailures++;
                            LOG_WARNING("尝试成为主节点失败，连续失败次数: " + std::to_string(consecutiveFailures));
                        }
                    } else {
                        LOG_DEBUG("距离上次选举尝试时间太短，等待下一次机会");
                    }
                }
            }
        } catch (const std::exception& e) {
            LOG_ERROR("选举循环异常: " + std::string(e.what()));
            std::this_thread::sleep_for(std::chrono::seconds(1));
        }
        
        // 等待更短的间隔时间，加快选举响应速度
        std::this_thread::sleep_for(std::chrono::seconds(3)); // 减小为3秒
    }
}

// 尝试成为主节点
bool NodeManager::tryBecomeLeader() {
    LOG_DEBUG("尝试成为主节点: nodeId=" + m_nodeId);
    
    // 如果节点处于故障状态，不允许成为主节点
    if (m_status == NodeStatus::FAULT) {
        LOG_WARNING("节点处于故障状态，无法成为主节点");
        return false;
    }
    
    try {
        // 首先检查是否已经有leader
        EtcdResult getResult = m_etcdClient->get(LEADER_KEY);
        
        // 如果已经有leader且不是自己，则不尝试成为leader
        if (getResult.success && !getResult.value.empty()) {
            if (getResult.value != m_nodeId) {
                LOG_DEBUG("已存在主节点: " + getResult.value + ", 当前节点: " + m_nodeId);
                
                // 检查当前主节点信息，如果状态异常，仍然尝试接管
                EtcdResult nodeResult = m_etcdClient->get(NODE_PREFIX + getResult.value);
                if (nodeResult.success && !nodeResult.value.empty()) {
                    NodeInfo leaderInfo;
                    if (deserializeNodeInfo(nodeResult.value, leaderInfo)) {
                        // 如果主节点处于故障状态或心跳超时，尝试接管
                        if (leaderInfo.status == NodeStatus::FAULT) {
                            LOG_INFO("当前主节点处于故障状态，尝试接管: " + getResult.value);
                            m_etcdClient->del(LEADER_KEY);
                            // 继续执行，尝试成为主节点
                        } else {
                            auto now = std::chrono::system_clock::now();
                            auto heartbeatAge = std::chrono::duration_cast<std::chrono::seconds>(
                                now - leaderInfo.lastHeartbeat).count();
                            
                            if (heartbeatAge > LEASE_TTL * 0.8) {
                                LOG_INFO("当前主节点心跳超时，尝试接管: " + getResult.value + 
                                        ", 心跳龄期: " + std::to_string(heartbeatAge) + "秒");
                                m_etcdClient->del(LEADER_KEY);
                                // 继续执行，尝试成为主节点
                            } else {
                                return false; // 主节点正常，无需接管
                            }
                        }
                    } else {
                        // 主节点信息解析失败，尝试接管
                        LOG_INFO("当前主节点信息解析失败，尝试接管: " + getResult.value);
                        m_etcdClient->del(LEADER_KEY);
                        // 继续执行，尝试成为主节点
                    }
                } else {
                    // 主节点信息获取失败，尝试接管
                    LOG_INFO("当前主节点信息获取失败，尝试接管: " + getResult.value);
                    m_etcdClient->del(LEADER_KEY);
                    // 继续执行，尝试成为主节点
                }
            } else {
                LOG_INFO("当前节点已经是主节点: " + m_nodeId);
                // 确保状态正确
                if (m_status != NodeStatus::LEADER) {
                    updateStatus(NodeStatus::LEADER);
                    updateNodeInfo();
                }
                return true;
            }
        }
        
        LOG_INFO("尝试设置主节点（无事务）: " + m_nodeId);
        
        // 直接尝试设置自己为主节点
        EtcdResult putResult = m_etcdClient->put(LEADER_KEY, m_nodeId, m_leaseId);
        
        if (putResult.success) {
            // 再次检查，确保设置成功
            EtcdResult verifyResult = m_etcdClient->get(LEADER_KEY);
            if (verifyResult.success && verifyResult.value == m_nodeId) {
                // 成功成为主节点
                LOG_INFO("成为主节点: nodeId=" + m_nodeId);
                updateStatus(NodeStatus::LEADER);
                updateNodeInfo();
                return true;
            } else {
                LOG_WARNING("Leader设置成功但验证失败，可能有竞争条件: " + 
                           (verifyResult.success ? verifyResult.value : verifyResult.errorMessage));
                return false;
            }
        } else {
            LOG_INFO("未能成为主节点: nodeId=" + m_nodeId + ", 原因: " + putResult.errorMessage);
            return false;
        }
    } catch (const std::exception& e) {
        LOG_ERROR("尝试成为主节点异常: " + std::string(e.what()));
        return false;
    }
}

// 检查主节点健康状态
void NodeManager::checkLeaderHealth(const std::string& leaderId) {
    LOG_DEBUG("检查主节点健康状态: leaderId=" + leaderId);
    
    try {
        // 如果leaderId为空，直接触发重新选举
        if (leaderId.empty()) {
            LOG_WARNING("主节点ID为空，触发重新选举");
            m_etcdClient->del(LEADER_KEY);
            
            // 从节点立即尝试成为主节点，不等待下一个选举周期
            if (m_status == NodeStatus::FOLLOWER) {
                LOG_INFO("旧主节点已故障，从节点主动尝试成为主节点");
                tryBecomeLeader();
            }
            return;
        }
        
        // 获取主节点信息
        EtcdResult result = m_etcdClient->get(NODE_PREFIX + leaderId);
        if (!result.success) {
            LOG_WARNING("获取主节点信息失败: " + result.errorMessage);
            // 只有在节点非故障状态时才删除主节点记录
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点信息获取失败，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点已故障，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        if (result.value.empty()) {
            LOG_WARNING("主节点信息为空");
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点信息为空，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点已故障，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        // 解析主节点信息
        NodeInfo leaderInfo;
        if (!deserializeNodeInfo(result.value, leaderInfo)) {
            LOG_WARNING("解析主节点信息失败: " + result.value);
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点信息解析失败，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点已故障，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        // 检查主节点状态
        if (leaderInfo.status != NodeStatus::LEADER) {
            LOG_WARNING("主节点状态不正确: " + nodeStatusToString(leaderInfo.status) + ", 应为: " + nodeStatusToString(NodeStatus::LEADER));
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点状态异常，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点状态异常，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        // 主节点进入故障状态，触发重新选举
        if (leaderInfo.status == NodeStatus::FAULT) {
            LOG_WARNING("主节点进入故障状态: " + leaderId);
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点故障，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点已故障，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        // 检查主节点心跳是否超时
        auto now = std::chrono::system_clock::now();
        auto diff = std::chrono::duration_cast<std::chrono::seconds>(
            now - leaderInfo.lastHeartbeat).count();
        
        if (diff > LEASE_TTL * 0.8) {  // 如果心跳时间超过租约TTL的80%
            LOG_WARNING("主节点心跳超时: " + std::to_string(diff) + "秒 (阈值: " + 
                       std::to_string(static_cast<int>(LEASE_TTL * 0.8)) + "秒)");
            if (m_status != NodeStatus::FAULT) {
                LOG_INFO("主节点心跳超时，触发重新选举");
                m_etcdClient->del(LEADER_KEY);
                
                // 从节点立即尝试成为主节点，不等待下一个选举周期
                if (m_status == NodeStatus::FOLLOWER) {
                    LOG_INFO("旧主节点心跳超时，从节点主动尝试成为主节点");
                    tryBecomeLeader();
                }
            }
            return;
        }
        
        LOG_DEBUG("主节点健康正常: " + leaderId);
    } catch (const std::exception& e) {
        LOG_ERROR("检查主节点健康状态异常: " + std::string(e.what()));
        // 只有在非故障状态且异常严重时才删除主节点记录
        if (m_status != NodeStatus::FAULT) {
            LOG_INFO("检查主节点健康状态出现异常，触发重新选举");
            m_etcdClient->del(LEADER_KEY);
            
            // 从节点立即尝试成为主节点，不等待下一个选举周期
            if (m_status == NodeStatus::FOLLOWER) {
                LOG_INFO("检查主节点异常，从节点主动尝试成为主节点");
                tryBecomeLeader();
            }
        }
    }
}

// 序列化节点信息
std::string NodeManager::serializeNodeInfo() const {
    Json::Value root;
    root["id"] = m_nodeId;
    root["endpoint"] = m_endpoint;
    root["status"] = static_cast<int>(m_status);
    
    // 格式化时间
    auto time_to_ms = [](const std::chrono::system_clock::time_point& tp) -> int64_t {
        return std::chrono::duration_cast<std::chrono::milliseconds>(tp.time_since_epoch()).count();
    };
    
    root["joinTime"] = Json::Value::Int64(time_to_ms(m_joinTime));
    root["lastHeartbeat"] = Json::Value::Int64(time_to_ms(m_lastHeartbeat));
    
    Json::FastWriter writer;
    return writer.write(root);
}

// 反序列化节点信息
bool NodeManager::deserializeNodeInfo(const std::string& json, NodeInfo& nodeInfo) const {
    try {
        Json::Value root;
        Json::Reader reader;
        
        if (!reader.parse(json, root)) {
            LOG_ERROR("JSON解析失败: " + json);
            return false;
        }
        
        nodeInfo.id = root["id"].asString();
        nodeInfo.endpoint = root["endpoint"].asString();
        nodeInfo.status = static_cast<NodeStatus>(root["status"].asInt());
        
        // 解析时间
        auto ms_to_time = [](int64_t ms) -> std::chrono::system_clock::time_point {
            return std::chrono::system_clock::time_point(std::chrono::milliseconds(ms));
        };
        
        // 安全地处理Int64转换
        try {
            if (root["joinTime"].isString()) {
                LOG_DEBUG("joinTime是字符串: '" + root["joinTime"].asString() + "', 尝试转换");
                nodeInfo.joinTime = ms_to_time(std::stoll(root["joinTime"].asString()));
            } else if (root["joinTime"].isInt64()) {
                nodeInfo.joinTime = ms_to_time(root["joinTime"].asInt64());
            } else if (root["joinTime"].isInt()) {
                nodeInfo.joinTime = ms_to_time(root["joinTime"].asInt());
            } else {
                LOG_WARNING("joinTime类型不支持: " + root["joinTime"].toStyledString());
                nodeInfo.joinTime = std::chrono::system_clock::now();
            }
            
            if (root["lastHeartbeat"].isString()) {
                LOG_DEBUG("lastHeartbeat是字符串: '" + root["lastHeartbeat"].asString() + "', 尝试转换");
                nodeInfo.lastHeartbeat = ms_to_time(std::stoll(root["lastHeartbeat"].asString()));
            } else if (root["lastHeartbeat"].isInt64()) {
                nodeInfo.lastHeartbeat = ms_to_time(root["lastHeartbeat"].asInt64());
            } else if (root["lastHeartbeat"].isInt()) {
                nodeInfo.lastHeartbeat = ms_to_time(root["lastHeartbeat"].asInt());
            } else {
                LOG_WARNING("lastHeartbeat类型不支持: " + root["lastHeartbeat"].toStyledString());
                nodeInfo.lastHeartbeat = std::chrono::system_clock::now();
            }
        } catch (const std::exception& e) {
            LOG_ERROR("时间转换异常: " + std::string(e.what()));
            // 使用当前时间作为默认值
            nodeInfo.joinTime = std::chrono::system_clock::now();
            nodeInfo.lastHeartbeat = std::chrono::system_clock::now();
        }
        
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("节点信息反序列化异常: " + std::string(e.what()));
        return false;
    }
}

// 将节点状态转换为字符串
std::string NodeManager::nodeStatusToString(NodeStatus status) const {
    switch (status) {
        case NodeStatus::UNKNOWN:
            return "未知";
        case NodeStatus::FOLLOWER:
            return "从节点";
        case NodeStatus::LEADER:
            return "主节点";
        case NodeStatus::FAULT:
            return "故障";
        default:
            return "未知状态";
    }
}

// 向后兼容的获取主节点方法
NodeInfo NodeManager::getLeaderNode() const {
    NodeInfo leader;
    leader.status = NodeStatus::UNKNOWN;
    
    try {
        // 从ETCD获取主节点ID
        EtcdResult result = m_etcdClient->get(LEADER_KEY);
        if (!result.success || result.value.empty()) {
            LOG_DEBUG("获取主节点ID失败或无主节点");
            return leader;
        }
        
        std::string leaderId = result.value;
        
        // 获取主节点详细信息
        EtcdResult nodeResult = m_etcdClient->get(NODE_PREFIX + leaderId);
        if (!nodeResult.success || nodeResult.value.empty()) {
            LOG_DEBUG("获取主节点详细信息失败或为空");
            return leader;
        }
        
        // 解析主节点信息
        if (!deserializeNodeInfo(nodeResult.value, leader)) {
            LOG_DEBUG("解析主节点信息失败");
            return leader;
        }
        
        // 验证节点状态
        if (leader.status != NodeStatus::LEADER) {
            LOG_DEBUG("主节点状态不正确: " + nodeStatusToString(leader.status));
            leader.status = NodeStatus::UNKNOWN;
        }
    } catch (const std::exception& e) {
        LOG_ERROR("获取主节点异常: " + std::string(e.what()));
    }
    
    return leader;
}

// 序列化节点基本信息（用于持久化存储）
std::string NodeManager::serializeBasicNodeInfo() const {
    Json::Value root;
    root["id"] = m_nodeId;
    root["endpoint"] = m_endpoint;
    root["status"] = static_cast<int>(m_status);
    root["createdAt"] = Json::Value::Int64(std::chrono::duration_cast<std::chrono::milliseconds>(
        m_joinTime.time_since_epoch()).count());
    
    // 如果是故障状态，添加故障时间
    if (m_status == NodeStatus::FAULT) {
        root["faultTime"] = Json::Value::Int64(std::chrono::duration_cast<std::chrono::milliseconds>(
            std::chrono::system_clock::now().time_since_epoch()).count());
    }
    
    Json::FastWriter writer;
    return writer.write(root);
}

// 加载持久化节点信息
void NodeManager::loadPersistentNodeInfo() {
    LOG_INFO("加载持久化节点信息");
    
    try {
        EtcdResult result = m_etcdClient->getPrefix(PERSISTENT_NODE_PREFIX);
        if (!result.success) {
            LOG_WARNING("获取持久化节点列表失败: " + result.errorMessage);
            return;
        }

        LOG_INFO("发现 " + std::to_string(result.kvs.size()) + " 个持久化节点记录");
        
        // 这里不进行过多处理，只是记录持久化节点的存在
        // 实际使用中可以根据需要加载这些节点的配置
    } catch (const std::exception& e) {
        LOG_ERROR("加载持久化节点信息异常: " + std::string(e.what()));
    }
}

// 保存持久化节点信息
bool NodeManager::savePersistentNodeInfo() {
    LOG_DEBUG("保存持久化节点信息: nodeId=" + m_nodeId);
    
    try {
        // 序列化节点基本信息
        std::string basicInfoJson = serializeBasicNodeInfo();
        
        // 将节点基本信息写入ETCD（不带租约，永久保存）
        EtcdResult result = m_etcdClient->put(PERSISTENT_NODE_PREFIX + m_nodeId, basicInfoJson);
        if (!result.success) {
            LOG_ERROR("保存持久化节点信息失败: " + result.errorMessage);
            return false;
        }
        
        LOG_DEBUG("持久化节点信息保存成功: nodeId=" + m_nodeId);
        return true;
    } catch (const std::exception& e) {
        LOG_ERROR("保存持久化节点信息异常: " + std::string(e.what()));
        return false;
    }
}

// 获取所有持久化节点信息
std::vector<NodeInfo> NodeManager::getAllPersistentNodes() const {
    LOG_DEBUG("获取所有持久化节点");
    
    std::vector<NodeInfo> nodes;
    try {
        EtcdResult result = m_etcdClient->getPrefix(PERSISTENT_NODE_PREFIX);
        if (!result.success) {
            LOG_ERROR("获取持久化节点列表失败: " + result.errorMessage);
            return nodes;
        }

        for (const auto& kv : result.kvs) {
            try {
                Json::Value root;
                Json::Reader reader;
                
                if (!reader.parse(kv.second, root)) {
                    LOG_WARNING("解析持久化节点JSON失败: " + kv.second);
                    continue;
                }
                
                NodeInfo nodeInfo;
                nodeInfo.id = root["id"].asString();
                nodeInfo.endpoint = root["endpoint"].asString();
                
                // 从持久化信息中读取状态（如果有）
                if (root.isMember("status")) {
                    nodeInfo.status = static_cast<NodeStatus>(root["status"].asInt());
                } else {
                    nodeInfo.status = NodeStatus::UNKNOWN; // 兼容没有状态信息的旧数据
                }
                
                // 处理时间信息
                if (root.isMember("createdAt")) {
                    auto ms_to_time = [](int64_t ms) -> std::chrono::system_clock::time_point {
                        return std::chrono::system_clock::time_point(std::chrono::milliseconds(ms));
                    };
                    
                    if (root["createdAt"].isInt64()) {
                        nodeInfo.joinTime = ms_to_time(root["createdAt"].asInt64());
                    } else if (root["createdAt"].isString()) {
                        nodeInfo.joinTime = ms_to_time(std::stoll(root["createdAt"].asString()));
                    } else {
                        nodeInfo.joinTime = std::chrono::system_clock::now();
                    }
                    
                    // 初始化lastHeartbeat为joinTime
                    nodeInfo.lastHeartbeat = nodeInfo.joinTime;
                } else {
                    nodeInfo.joinTime = std::chrono::system_clock::now();
                    nodeInfo.lastHeartbeat = nodeInfo.joinTime;
                }
                
                // 尝试从活动节点获取更详细的信息
                EtcdResult activeResult = m_etcdClient->get(NODE_PREFIX + nodeInfo.id);
                if (activeResult.success && !activeResult.value.empty()) {
                    NodeInfo activeInfo;
                    if (deserializeNodeInfo(activeResult.value, activeInfo)) {
                        // 使用活动节点的状态和时间信息（如果活动节点存在）
                        nodeInfo.status = activeInfo.status;
                        nodeInfo.lastHeartbeat = activeInfo.lastHeartbeat;
                        // 保留持久化节点的joinTime
                    }
                }
                
                nodes.push_back(nodeInfo);
            } catch (const std::exception& e) {
                LOG_WARNING("处理持久化节点信息异常: " + std::string(e.what()));
            }
        }
    } catch (const std::exception& e) {
        LOG_ERROR("获取持久化节点列表异常: " + std::string(e.what()));
    }
    
    LOG_DEBUG("找到持久化节点数量: " + std::to_string(nodes.size()));
    return nodes;
}

// 保存持久化节点信息
// 注册外部节点
